GermanWikipedia - /page/entry.mu

<!DOCTYPE html>

<title>Generische Programmierung in Java</title>

</head>

<h1 id="firstHeading" class="firstHeading mw-first-heading">Generische Programmierung in Java</h1>

</header>

</div>

<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><a href="Generische_Programmierung" title="Generische Programmierung">Generische Programmierung</a> in <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> wird durch sog. Generics seit Java 1.5 ermöglicht. Der Begriff steht synonym für „parametrisierte Typen“. Die Idee dahinter ist, zusätzliche <a href="Variable_(Programmierung)" title="Variable (Programmierung)">Variablen</a> für <a href="Datentyp" title="Datentyp">Datentypen</a> einzuführen. Diese Typ-Variablen repräsentieren zum Zeitpunkt der Implementierung unbekannte Typen. Erst bei der Verwendung der <a href="Klasse_(objektorientierte_Programmierung)" class="mw-redirect" title="Klasse (objektorientierte Programmierung)">Klassen</a>, <a href="Schnittstelle_(Objektorientierung)" title="Schnittstelle (Objektorientierung)">Schnittstellen</a> und <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a> werden diese Typ-Variablen durch konkrete Typen ersetzt. Damit kann <a href="Typsicherheit" title="Typsicherheit">typsichere</a> Programmierung meistens gewährleistet werden. Jedoch nicht immer.<a href="#cite_note-1">[1]</a>

<div class="mw-heading mw-heading2"><h2 id="Das_Konzept">Das Konzept</h2></div>

Ab Version 5.0 („Tiger“, 2004 veröffentlicht) steht auch in der Programmiersprache Java mit den Generics ein <a href="Syntax" title="Syntax">syntaktisches</a> Mittel für die generische Programmierung zur Verfügung. Damit lassen sich Klassen und Methoden (Methoden auch unabhängig von ihren Klassen) mit Typen parametrisieren.

Damit werden der Sprache einige ähnliche Möglichkeiten eröffnet, die sich vergleichbar bei den <a href="Template_(Programmierung)" class="mw-redirect" title="Template (Programmierung)">Templates</a> in <a href="C%2B%2B" title="C++">C++</a> bieten.

Prinzipiell gibt es aber durchaus wesentliche Unterschiede. Während in Java über die Schnittstelle der Typparameter parametrisiert wird, wird in C++ direkt über den Typ des Typparameters selbst parametrisiert. Der <a href="Quelltext" title="Quelltext">Quelltext</a> eines C++-Templates muss für den Anwender (d. h. beim Einsetzen des Typparameters) verfügbar sein, während ein <a href="Generischer_Typ" title="Generischer Typ">generischer Java-Typ</a> auch als übersetzter <a href="Bytecode" title="Bytecode">Bytecode</a> veröffentlicht werden kann. Für verschiedene konkret verwendete Typparameter produziert der <a href="Compiler" title="Compiler">Compiler</a> duplizierten Zielcode.

Beispielsweise bietet die Funktion <code>std::sort</code> in C++ die Möglichkeit, alle <a href="Container_(Informatik)" title="Container (Informatik)">Container</a> zu sortieren, die bestimmte Methoden anbieten (hier speziell <code>begin()</code> und <code>end()</code>, die jeweils einen <a href="Iterator" title="Iterator">Iterator</a> liefern) und deren Typparameter den <code>operator<</code> implementiert (oder explizit eine andere Vergleichsfunktion angegeben wurde). Ein Nachteil, der sich durch dieses System ergibt, ist die (für den Programmierer!) schwierigere Übersetzung. Der Compiler hat keine andere Möglichkeit, als den Typparameter in jedem Fall durch den geforderten konkreten Typ zu ersetzen und den ganzen Code erneut zu kompilieren.

Sehr leicht können bei unpassenden Typparametern und anderen Problemen komplizierte und unverständliche Compiler-Meldungen entstehen, was einfach mit der Tatsache zusammenhängt, dass die konkreten Anforderungen an die Typparameter unbekannt sind. Die Arbeit mit C++-Templates erfordert deshalb eine lückenlose Dokumentation der Anforderungen an einen Typparameter. Durch Template-<a href="Metaprogrammierung" title="Metaprogrammierung">Metaprogrammierung</a> können die meisten Anforderungen (<a href="Basisklasse" title="Basisklasse">Basisklasse</a>, Vorhandensein von Methoden, Kopierbarkeit, Zuweisbarkeit etc.) auch in speziellen Konstrukten abgefragt werden, wodurch sich lesbarere Fehlermeldungen ergeben. Obgleich sie standardkonform sind, werden diese Konstrukte jedoch nicht von allen Compilern unterstützt.

Dagegen sind den generischen Klassen und Methoden in Java die Anforderungen (<a href="Englische_Sprache" title="Englische Sprache">englisch</a> constraints) an ihre eigenen Typparameter bekannt. Um eine Collection (ohne Comparator) zu sortieren, müssen die enthaltenen Elemente vom Typ Comparable sein, also dieses Interface implementiert haben. Der Compiler muss lediglich prüfen, ob der Typparameter ein Untertyp von Comparable ist, und kann damit schon sicherstellen, dass der Code korrekt ist (d. h. die erforderliche Methode compareTo verfügbar ist). Weiterhin wird ein und derselbe Code für alle konkreten Typen verwendet und nicht jedes Mal dupliziert.

<div class="mw-heading mw-heading2"><h2 id="Praktische_Beispiele">Praktische Beispiele</h2></div>

Ein Programm verwendet eine <code>ArrayList</code>, um eine <a href="Liste_(Datenstruktur)" title="Liste (Datenstruktur)">Liste</a> von <code>JButton</code>s zu speichern.

Bisher war die <code>ArrayList</code> auf den Typ <code>Object</code> fixiert:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List list = new ArrayList();

list.add(new JButton("Button 1"));

list.add(new JButton("Button 2"));

list.add(new JButton("Button 3"));

list.add(new JButton("Button 4"));

list.add(new JButton("Button 5"));

for (int i = 0; i < list.size(); i++) {

JButton button = (JButton) list.get(i);

button.setBackground(Color.white);

}

</pre></div>

Man beachte die notwendige <a href="Typumwandlung" title="Typumwandlung">explizite Typumwandlung</a> (auch „Cast“ genannt) sowie die Typunsicherheit, die damit verbunden ist. Man könnte versehentlich ein <a href="Objekt_(Programmierung)" title="Objekt (Programmierung)">Objekt</a> in der <code>ArrayList</code> speichern, das keine Instanz der Klasse <code>JButton</code> ist. Die Information über den genauen Typ geht beim Einfügen in die Liste verloren, der Compiler kann also nicht verhindern, dass zur <a href="Laufzeit_(Informatik)" title="Laufzeit (Informatik)">Laufzeit</a> bei der expliziten Typumwandlung von <code>JButton</code> eine <code>ClassCastException</code> auftritt.

Mit generischen Typen ist in Java Folgendes möglich:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<JButton> list = new ArrayList<JButton>();

list.add(new JButton("Button 1"));

list.add(new JButton("Button 2"));

list.add(new JButton("Button 3"));

list.add(new JButton("Button 4"));

list.add(new JButton("Button 5"));

for (int i = 0; i < list.size(); i++)

list.get(i).setBackground(Color.white);

</pre></div>

Beim Auslesen ist nun keine explizite Typumwandlung mehr notwendig, beim Speichern ist es nur noch möglich, JButtons in der <code>ArrayList</code> list abzulegen.

Ab Java7 ist die Instanzierung generischer Typen vereinfacht worden. Die erste Zeile in obigem Beispiel kann seit Java 7 folgendermaßen geschrieben werden:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<JButton> list = new ArrayList<>();

</pre></div>

Die beiden leeren spitzen Klammern werden aufgrund ihrer Form auch als Diamant-Operator (<a href="Englische_Sprache" title="Englische Sprache">englisch</a> Diamond-Operator) bezeichnet.<a href="#cite_note-2">[2]</a><a href="#cite_note-3">[3]</a>

Durch Kombination von generischen Typen mit den erweiterten For-Schleifen lässt sich obiges Beispiel kürzer fassen:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<JButton> list = new ArrayList<>();

list.add(new JButton("Button 1"));

list.add(new JButton("Button 2"));

list.add(new JButton("Button 3"));

list.add(new JButton("Button 4"));

list.add(new JButton("Button 5"));

for (JButton b: list)

b.setBackground(Color.white);

</pre></div>

Ein Beispiel für eine generische Klasse, die zwei Objekte von beliebigem, aber einander gleichem Typ beinhaltet, liefert der folgende Beispielcode:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public class DoubleObject<T> {

private T object1;

private T object2;

public DoubleObject(T object1, T object2) {

this.object1 = object1;

this.object2 = object2;

}

public String toString() {

return this.object1 + ", " + this.object2;

}

public static void main(String[] args) {

DoubleObject<String> s = new DoubleObject<>("abc", "def");

DoubleObject<Integer> i = new DoubleObject<>(123, 456);

System.out.println("DoubleObject<String> s=" + s.toString());

System.out.println("DoubleObject<Integer> i=" + i.toString());

}

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Varianzfälle">Varianzfälle</h2></div>

In Java können die nachfolgenden Varianzfälle unterschieden werden. Sie bieten jeweils eine völlig eigenständige Flexibilität beim Umgang mit generischen Typen und sind jeweils absolut statisch typsicher.

<div class="mw-heading mw-heading3"><h3 id="Invarianz">Invarianz</h3></div>

Bei Invarianz ist der Typparameter eindeutig. Damit bietet Invarianz die größtmögliche Freiheit bei der Benutzung des Typparameters. Beispielsweise sind für die Elemente einer <code>ArrayList<Integer></code> alle Aktionen erlaubt, die auch bei der direkten Benutzung eines einzelnen Integers erlaubt sind (inklusive <a href="Autoboxing" class="mw-redirect" title="Autoboxing">Autoboxing</a>). Beispiel:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<Integer> list = new ArrayList<Integer>();

// ...

Integer x = list.get(index);

list.get(index).methodeVonInteger();

list.set(index, 98347); // Autoboxing, entspricht Integer.valueOf(98347)

int y = list.get(index); // Auto-Unboxing

</pre></div>

Diese Möglichkeiten werden mit wenig Flexibilität bei der <a href="Zuweisung" title="Zuweisung">Zuweisung</a> von Objekten der generischen Klasse selbst erkauft. Beispielsweise ist Folgendes nicht erlaubt:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<Number> list = new ArrayList<Integer>();

</pre></div>

und das, obwohl Integer von Number abgeleitet ist. Der Grund liegt darin, dass der Compiler hier nicht mehr sicherstellen kann, dass keine Typfehler auftreten. Mit <a href="Array_(Datentyp)" title="Array (Datentyp)">Arrays</a>, die eine solche Zuweisung erlauben, hat man schlechte Erfahrungen gemacht:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// OK, Integer[] ist abgeleitet von Number[]

Number[] array = new Integer[10];

// ArrayStoreException zur Laufzeit: Double -> Integer sind nicht

// zuweisungskompatibel

array[0] = new Double(5.0);

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Kovarianz">Kovarianz</h3></div>

Man bezeichnet Arrays als <a href="Kovarianz_und_Kontravarianz" title="Kovarianz und Kontravarianz">kovariant</a>, was besagt:

<div>Aus T extends V folgt: T[] extends V[]</div>

oder allgemeiner:

<div>Aus T extends V folgt: GenerischerTyp<T> extends GenerischerTyp<V></div>

Es verhält sich also der Array-Typ bzgl. der <a href="Vererbung_(Programmierung)" title="Vererbung (Programmierung)">Vererbungshierarchie</a> genauso wie der Typparameter.

Kovarianz ist auch mit generischen Typen möglich, allerdings nur mit Einschränkungen, so dass Typfehler zur <a href="%C3%9Cbersetzungszeit" title="Übersetzungszeit">Kompilierzeit</a> ausgeschlossen werden können.

Referenzen müssen mit der Syntax ? extends T explizit als kovariant gekennzeichnet werden. T heißt upper typebound, also der allgemeinste Typparameter, der erlaubt ist.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<? extends Number> list;

list = new ArrayList<Double>();

list = new ArrayList<Long>();

list = new ArrayList<Integer>();

// Typfehler vom Compiler

list.set(index, myInteger);

// OK aber Warnung vom Compiler: unchecked cast

((List<Integer>) list).set(index, myInteger);

</pre></div>

Das Ablegen von Elementen in diesen Listen ist nicht möglich, da dies, wie oben beschrieben, nicht typsicher ist (Ausnahme: <code><a href="Nullwert" title="Nullwert">null</a></code> kann abgelegt werden). Bereits zur Kompilierzeit tritt ein Fehler auf. Allgemeiner gesagt, ist die Zuweisung

<div>? → ? extends T</div>

nicht erlaubt.

Möglich dagegen ist das Auslesen von Elementen:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>Number n = list.get(index); // OK

Integer i = list.get(index); // Typfehler: Es muss sich bei '? extends Number'

// nicht um ein Integer handeln.

Integer j = (Integer) list.get(index); // OK

</pre></div>

Die Zuweisung

<div>? extends T → T (oder Basisklasse)</div>

ist also erlaubt, nicht aber die Zuweisung

<div>? extends T → abgeleitet von T</div>

Generics bieten also wie Arrays kovariantes Verhalten, verbieten aber alle Operationen, die typunsicher sind.

<div class="mw-heading mw-heading3"><h3 id="Kontravarianz">Kontravarianz</h3></div>

Kontravarianz bezeichnet das Verhalten der Vererbungshierarchie des generischen Typs entgegen der Hierarchie seines Typparameters. Übertragen auf das obige Beispiel würde das bedeuten: Eine Liste<Number> wäre zuweisungskompatibel zu einer Liste<Double>.

Dies wird folgendermaßen bewerkstelligt:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<? super Double> list;

list = new ArrayList<Number>();

list = new ArrayList<Double>();

list = new ArrayList<Object>();

</pre></div>

Ein Objekt, das sich kontravariant verhält, darf keine Annahmen darüber machen, inwiefern ein Element vom Typ V von T abgeleitet ist, wobei T der lower Typebound ist (im Beispiel von <code style="white-space: nowrap">? super Double</code> ist T <code>Double</code>).

Deshalb kann aus den obigen Listen nicht gelesen werden:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// Fehler: 'list' könnte vom Typ List<Object> sein

Number x = list.get(index);

// Fehler: 'list' könnte List<Object> oder List<Number> sein

Double x = list.get(index);

// Die einzige Ausnahme: Objects sind auf jeden Fall in der Liste

Object x = list.get(index);

</pre></div>

Nicht erlaubt, da nicht typsicher, ist also die Zuweisung ? super T → (abgeleitet von Object)

Unschwer zu erraten: Im Gegenzug kann in eine solche Liste ein Element abgelegt werden:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<? super Number> list;

list.add(new Double(3.0)); // OK: 'list' hat immer den Typ List<Number>

// oder List<Basisklasse von Number>. Damit

// ist die Zuweisung Double -> T immer erlaubt.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Uneingeschränkte_parametrische_Polymorphie">Uneingeschränkte parametrische Polymorphie</h3></div>

Zu guter Letzt bieten Generics noch gänzlich polymorphes Verhalten an. Hierbei kann keinerlei Aussage über die Typparameter gemacht werden, denn es wird in beide Richtungen keine Grenze angegeben. Dafür wurde die <a href="Wildcard_(Java)" title="Wildcard (Java)">Wildcard</a> definiert. Sie wird durch ein Fragezeichen repräsentiert.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<?> list;

list = new ArrayList<Integer>();

list = new ArrayList<Object>();

list = new ArrayList<String>();

// ...

</pre></div>

Der Typparameter selbst kann hierbei nicht genutzt werden, da keine Aussage möglich ist. Lediglich die Zuweisung T → Object ist erlaubt, da T auf jeden Fall ein Object ist. Im Gegenzug ist garantiert, dass der Code mit allen Ts arbeiten kann.

Nützlich kann so etwas sein, wenn man nur mit dem generischen Typ arbeitet:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>// Keine Informationen über den Typparameter nötig, kann ''beliebige'' Listen

// aufnehmen.

int readSize(List<?> list) {

return list.size();

}

</pre></div>

Zur Verdeutlichung, dass hier Wildcards unnötig sind, und es eigentlich gar nicht um irgendeine Varianz geht, sei folgende Implementierung der obigen Funktion angegeben:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><T> int readSize(List<T> list) {

return list.size();

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>

<ul><li>Ina Brenner: <a rel="nofollow" class="external text" href="https://www.theserverside.de/java-generics-generische-methoden-klassen-und-interfaces/">Tutorial zu Generics in Java</a> von der Autorin eines Buchs zur Java-Zertifizierung SCJP</li>

<li>Klaus Kreft, Angelika Langer: <a rel="nofollow" class="external text" href="https://angelikalanger.com/Articles/Topics.html#JavaGenerics/">Artikelserie zu Generics in Java</a> im JavaSpektrum</li>

<li><a href="Christian_Ullenboom" title="Christian Ullenboom">Christian Ullenboom</a>: <a rel="nofollow" class="external text" href="https://openbook.rheinwerk-verlag.de/javainsel/12_001.html">Kapitel zu Generischen Datentypen</a> aus dem Galileo-Openbook Java ist auch eine Insel</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>

<li id="cite_note-1"><a href="#cite_ref-1">↑</a> Nada Amin, Ross Tate: <cite class="lang" lang="en" dir="auto" style="font-style:italic">Java and Scala’s Type Systems are Unsound: The Existential Crisis of Null Pointers</cite>. In: ACM (Hrsg.): <cite class="lang" lang="en" dir="auto" style="font-style:italic"><a href="OOPSLA" title="OOPSLA">OOPSLA</a> 2016</cite>. New York 2016, ISBN 978-1-4503-4444-9, S. 838–848 (englisch, <a rel="nofollow" class="external text" href="https://raw.githubusercontent.com/namin/unsound/master/doc/unsound-oopsla16.pdf">githubusercontent.com</a> [PDF; 215 kB; abgerufen am 31. März 2017]).<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Generische+Programmierung+in+Java&rft.atitle=Java+and+Scala%E2%80%99s+Type+Systems+are+Unsound%3A+The+Existential+Crisis+of+Null+Pointers&rft.au=Nada+Amin%2C+Ross+Tate&rft.btitle=OOPSLA+2016&rft.date=2016&rft.genre=book&rft.isbn=9781450344449&rft.pages=838-848&rft.place=New+York" style="display:none">

</li>

<li id="cite_note-2"><a href="#cite_ref-2">↑</a> Joachim Goll, Cornelia Heinisch: <cite style="font-style:italic">Java als erste Programmiersprache: Grundkurs für Hochschulen</cite>. 8. Auflage. Springer, Wiesbaden 2016, ISBN 978-3-658-12117-4, S. 725.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Generische+Programmierung+in+Java&rft.au=Joachim+Goll%2C+Cornelia+Heinisch&rft.btitle=Java+als+erste+Programmiersprache%3A+Grundkurs+f%C3%BCr+Hochschulen&rft.date=2016&rft.edition=8&rft.genre=book&rft.isbn=9783658121174&rft.pages=725&rft.place=Wiesbaden&rft.pub=Springer" style="display:none">

</li>

<li id="cite_note-3"><a href="#cite_ref-3">↑</a> Reinhard Schiedermeier: <cite style="font-style:italic">Programmieren mit Java</cite>. 2. Auflage. Pearson Studium, München 2010, ISBN 978-3-86894-031-2, S. 375.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Generische+Programmierung+in+Java&rft.au=Reinhard+Schiedermeier&rft.btitle=Programmieren+mit+Java&rft.date=2010&rft.edition=2&rft.genre=book&rft.isbn=9783868940312&rft.pages=375&rft.place=M%C3%BCnchen&rft.pub=Pearson+Studium" style="display:none">

</li>

</ol></div><div><div class="zim-footer">

Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-08-13" href="https://de.wikipedia.org/wiki/?title=Generische_Programmierung_in_Java&oldid=258832035">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.

</div>

</div></div>

</div>

</main>

</div>

</body></html>